JavaScript Switch Statement

Switch கட்டுப்பாட்டு ஓட்டத்தைப் பயன்படுத்தி மடங்கு நிபந்தனைகளைக் கையாள கற்றுக்கொள்ளுங்கள்

Switch கட்டுப்பாட்டு ஓட்டம்

ஒரு நிபந்தனையின் அடிப்படையில், switch ஒன்று அல்லது அதற்கு மேற்பட்ட குறியீடு தொகுதிகளைச் செயல்படுத்தத் தேர்ந்தெடுக்கிறது.

switch ஒரு வெளிப்பாட்டுடன் பொருந்தக்கூடிய குறியீடு தொகுதிகளை செயல்படுத்துகிறது.

switch பல if...else if...else அறிக்கைகளுக்கு மிகவும் வாசிக்கக்கூடிய மாற்றாக பயன்படுத்தப்படுகிறது, குறிப்பாக பல சாத்தியமான மதிப்புகளைக் கையாளும் போது.

தொடரியல்

switch(expression) {
  case x:
    // குறியீடு தொகுதி
    break;
  case y:
    // குறியீடு தொகுதி
    break;
  default:
    // குறியீடு தொகுதி
}

இது எவ்வாறு செயல்படுகிறது:

மதிப்பீடு: switch வெளிப்பாடு ஒருமுறை மதிப்பீடு செய்யப்படுகிறது
ஒப்பீடு: வெளிப்பாட்டின் மதிப்பு ஒவ்வொரு case இன் மதிப்புகளுடன் ஒப்பிடப்படுகிறது
இயக்கம்: பொருத்தம் இருந்தால், தொடர்புடைய குறியீடு தொகுதி செயல்படுத்தப்படுகிறது
இல்லாத பொருத்தம்: பொருத்தம் இல்லையென்றால், எந்த குறியீடும் இயக்கப்படாது

எடுத்துக்காட்டு

இந்த எடுத்துக்காட்டு வார நாள் எண்ணைக் கணக்கிட வார நாள் பெயரைப் பயன்படுத்துகிறது:

switch (new Date().getDay()) {
  case 0:
    day = "Sunday";
    break;
  case 1:
    day = "Monday";
    break;
  case 2:
     day = "Tuesday";
    break;
  case 3:
    day = "Wednesday";
    break;
  case 4:
    day = "Thursday";
    break;
  case 5:
    day = "Friday";
    break;
  case 6:
    day = "Saturday";
}

📅 குறிப்பு:

getDay() முறை வார நாளை 0 மற்றும் 6 க்கு இடையில் ஒரு எண்ணாக வழங்குகிறது.

(ஞாயிறு=0, திங்கள்=1, செவ்வாய்=2 ..)

break கீ வேர்டு

JavaScript ஒரு break கீ வேர்டை அடையும் போது, அது switch தொகுதியிலிருந்து வெளியேறுகிறது.

இது switch தொகுதிக்குள் இயக்கத்தை நிறுத்தும்.

switch தொகுதியில் மேலும் அறிக்கைகள் செயல்படுத்தப்படாது.

கடைசி case ஐ break செய்ய வேண்டிய அவசியமில்லை. switch அங்கேயே முடிகிறது (break).

⚠️ குறிப்பு:

break கீ வேர்டு "fall-through" ஐத் தடுப்பதற்கு முக்கியமானது.

break இல்லாமல், அவற்றின் மதிப்புகள் வெளிப்பாட்டுடன் பொருந்தாவிட்டாலும், குறியீடு அடுத்த case தொகுதிகளை (மற்றும் default தொகுதி இருந்தால்) தொடர்ந்து இயக்கும்.

break இல்லாமல் எடுத்துக்காட்டு:

let result = "";
let day = 2;

switch (day) {
  case 0:
    result += "Sunday ";
  case 1:
    result += "Monday ";
  case 2:
    result += "Tuesday ";
  case 3:
    result += "Wednesday ";
  default:
    result += "Other day";
}

console.log(result); // "Tuesday Wednesday Other day"

default கீ வேர்டு

default கீ வேர்டு case பொருத்தம் இல்லையென்றால் இயக்கப்பட வேண்டிய ஒரு குறியீடு தொகுதியைக் குறிப்பிடுகிறது.

default கீ வேர்டு விருப்பத்தேர்வு.

default ஒரு fallback ஆக செயல்படலாம்:

எடுத்துக்காட்டு

getDay() முறை வார நாளை 0 மற்றும் 6 க்கு இடையில் ஒரு எண்ணாக வழங்குகிறது.

இன்று சனிக்கிழமை (6) அல்லது ஞாயிற்றுக்கிழமை (0) இல்லையென்றால், ஒரு default செய்தியை எழுதுங்கள்:

switch (new Date().getDay()) {
  case 6:
    text = "Today is Saturday";
    break;
  case 0:
    text = "Today is Sunday";
    break;
  default:
    text = "Looking forward to the Weekend";
}

text இன் முடிவு இருக்கும்:

"Looking forward to the Weekend"

default case switch தொகுதியில் கடைசி case ஆக இருக்க வேண்டியதில்லை:

switch (new Date().getDay()) {
  default:
    text = "Looking forward to the Weekend";
    break;
  case 6:
    text = "Today is Saturday";
    break;
  case 0:
    text = "Today is Sunday";
}

💡 கவனிக்க:

default switch தொகுதியில் கடைசி case ஆக இல்லாவிட்டால், default case ஐ break உடன் முடிக்க நினைவில் கொள்ளுங்கள்.

பொதுவான குறியீடு தொகுதிகள்

சில நேரங்களில் வெவ்வேறு switch case கள் ஒரே குறியீட்டைப் பயன்படுத்த நீங்கள் விரும்பலாம்.

இந்த எடுத்துக்காட்டில் case 4 மற்றும் 5 ஒரே குறியீடு தொகுதியைப் பகிர்ந்து கொள்கின்றன, மற்றும் 0 மற்றும் 6 மற்றொரு குறியீடு தொகுதியைப் பகிர்ந்து கொள்கின்றன:

switch (new Date().getDay()) {
  case 4:
  case 5:
    text = "Soon it is Weekend";
    break;
  case 0:
  case 6:
    text = "It is Weekend";
    break;
  default:
    text = "Looking forward to the Weekend";
}

மேலும் எடுத்துக்காட்டுகள்:

// மாதங்களை பருவங்களாக வகைப்படுத்துதல்
let month = new Date().getMonth();
let season;

switch (month) {
  case 11: case 0: case 1:
    season = "Winter";
    break;
  case 2: case 3: case 4:
    season = "Spring";
    break;
  case 5: case 6: case 7:
    season = "Summer";
    break;
  case 8: case 9: case 10:
    season = "Autumn";
    break;
  default:
    season = "Invalid month";
}

// கிரேடுகளை வகைப்படுத்துதல்
let grade = 'B';
let result;

switch(grade) {
  case 'A': case 'B': case 'C':
    result = "Pass";
    break;
  case 'D': case 'F':
    result = "Fail";
    break;
  default:
    result = "Invalid grade";
}

Switch விவரங்கள்

பல பொருத்தங்கள்: பல case கள் ஒரு case மதிப்புடன் பொருந்தினால், முதல் case தேர்ந்தெடுக்கப்படுகிறது
பொருத்தம் இல்லை: பொருத்தமான case கள் கிடைக்கவில்லை என்றால், நிரல் default லேபிளுக்கு தொடர்கிறது
default இல்லை: default லேபிள் கிடைக்கவில்லை என்றால், நிரல் switch க்குப் பிறகு உள்ள அறிக்கை(கள்)க்குத் தொடர்கிறது

கண்டிப்பான ஒப்பீடு

Switch கண்டிப்பான ஒப்பீடு (===) பயன்படுத்துகிறது.

பொருத்துவதற்கு மதிப்புகள் ஒரே வகையில் இருக்க வேண்டும்.

இரண்டு செயலிகள் ஒரே வகையில் இருந்தால் மட்டுமே கண்டிப்பான ஒப்பீடு true ஆக இருக்க முடியும்.

எடுத்துக்காட்டு

இந்த எடுத்துக்காட்டில் x க்கு பொருத்தம் இல்லை:

let x = "0";
switch (x) {
  case 0:
    text = "Off";
    break;
  case 1:
    text = "On";
    break;
  default:
    text = "No value found";
}

மேலே உள்ள எடுத்துக்காட்டில், x என்பது "0" (சரம்), ஆனால் case 0 0 (எண்) உடன் ஒப்பிடப்படுகிறது. கண்டிப்பான ஒப்பீடு காரணமாக, அவை பொருந்தாது, எனவே default case இயக்கப்படும்.

🔍 Switch vs If...else ஒப்பீடு:

Switch (கண்டிப்பான)

let value = "2";
switch(value) {
  case 2:    // பொருந்தாது
    console.log("Number 2");
    break;
  case "2":  // பொருந்தும்
    console.log("String '2'");
    break;
}

If...else (வகை மாற்றம்)

let value = "2";
if (value == 2) {    // பொருந்தும் (வகை மாற்றம்)
  console.log("Number 2");
} else if (value === "2") {
  console.log("String '2'");
}

Switch vs If...Else

அம்சம் Switch If...Else
ஒப்பீடு முறை கண்டிப்பான ஒப்பீடு (===) வகை மாற்றம் அல்லது கண்டிப்பானது
வெளிப்பாடு ஒற்றை வெளிப்பாட்டை மதிப்பிடுகிறது பல வெவ்வேறு வெளிப்பாடுகளை மதிப்பிடலாம்
சிக்கலான நிபந்தனைகள் ஒற்றை மதிப்புகள்/வரம்புகள் சிக்கலான தர்க்கம், வரம்புகள், தருக்க செயலிகள்
வாசிப்புத்தன்மை பல மதிப்புகளுக்கு நல்லது சிக்கலான தர்க்கத்திற்கு நல்லது
செயல்திறன் பல case களுக்கு வேகமானது சில நிபந்தனைகளுக்கு வேகமானது

எப்போது Switch பயன்படுத்துவது:

பல தனிப்பட்ட மதிப்புகள்: ஒரு மாறிக்கு பல குறிப்பிட்ட மதிப்புகளை சரிபார்க்கும்போது
எனும்அறிக்கைகள்: ஒரே வெளிப்பாட்டை பல முறை மதிப்பிடுவதைத் தவிர்க்கும்போது
வாசிப்புத்தன்மை: பல if...else if அறிக்கைகளை விட தெளிவான குறியீடு தேவைப்படும் போது

எப்போது If...Else பயன்படுத்துவது:

வரம்புகள்: மதிப்பு வரம்புகளை சோதிக்கும்போது (x > 10)
பல வெவ்வேறு வெளிப்பாடுகள்: வெவ்வேறு மாறிகள் அல்லது வெளிப்பாடுகளை சோதிக்கும்போது
தருக்க செயலிகள்: சிக்கலான தர்க்கம் தேவைப்படும் போது (&&, ||, !)

மேம்பட்ட Switch எடுத்துக்காட்டுகள்

// ஒரு செயல்பாட்டின் முடிவைப் பயன்படுத்துதல்
switch (getUserRole()) {
  case 'admin':
    showAdminPanel();
    break;
  case 'editor':
    showEditorPanel();
    break;
  case 'viewer':
    showViewerPanel();
    break;
  default:
    showLoginScreen();
}

// வெளிப்பாடுகளுடன் Switch
let score = 85;
let grade;

switch (true) {
  case score >= 90:
    grade = 'A';
    break;
  case score >= 80:
    grade = 'B';
    break;
  case score >= 70:
    grade = 'C';
    break;
  case score >= 60:
    grade = 'D';
    break;
  default:
    grade = 'F';
}

// கலப்பு தரவு வகைகள்
let input = getUserInput();

switch (typeof input) {
  case 'string':
    console.log('Input is a string:', input.toUpperCase());
    break;
  case 'number':
    console.log('Input is a number:', input * 2);
    break;
  case 'boolean':
    console.log('Input is boolean:', !input);
    break;
  default:
    console.log('Unknown input type');
}

JavaScript Switch Statement பயிற்சி

switch அறிக்கை பற்றிய உங்கள் அறிவைச் சோதிக்க இந்தப் பயிற்சியை முயற்சிக்கவும்.

பின்வரும் எது switch அறிக்கையில் ஒரு கீ வேர்ட் அல்ல?

switch
✗ தவறு! switch என்பது switch அறிக்கையைத் தொடங்க பயன்படும் முக்கிய கீ வேர்ட் ஆகும்
break
✗ தவறு! break என்பது ஒரு case இலிருந்து வெளியேற பயன்படும் கீ வேர்ட் ஆகும், இது "fall-through" ஐத் தடுக்கிறது
continue
✓ சரி! continue என்பது switch அறிக்கையில் கீ வேர்ட் அல்ல. continue loops இல் பயன்படுத்தப்படுகிறது, switch இல் அல்ல. switch அறிக்கையில் பயன்படுத்தப்படும் கீ வேர்ட்கள்: switch, case, break, மற்றும் default
default
✗ தவறு! default என்பது எந்த case பொருத்தமும் இல்லாதபோது இயக்கப்படும் குறியீடு தொகுதியை வரையறுக்கப் பயன்படும் கீ வேர்ட் ஆகும்